#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
IR 字符串表达式节点定义
"""

import ast
from dataclasses import dataclass, field
from typing import List as TypingList, Iterator, Optional
from .base import IRExpr, build_expr_from_ast
from ..base import IRNode, get_default_ir_node


@dataclass
class IRSFormat(IRExpr):
    """格式化字符串表达式"""

    format_str: str = field(default="")
    named_args: TypingList[tuple[str, IRNode]] = field(default_factory=list)
    is_format_str_literal: bool = field(default=True)
    format_str_expr: IRNode = field(default_factory=get_default_ir_node)
    is_fstring: bool = field(default=False)
    kwargs: Optional[IRNode] = field(default=None)
    node_type: str = "sformat"

    def get_child_nodes(self) -> Iterator[IRNode]:
        """获取所有子节点"""
        # 格式字符串表达式
        yield self.format_str_expr

        # 命名参数值
        for _, value in self.named_args:
            yield value
        yield from super().get_child_nodes()

    def build_from_ast(self, node) -> None:
        """从 AST JoinedStr 节点构建 IR SFormat 节点内容

        Args:
            node: AST JoinedStr 节点（f-string）
        """

        super().build_from_ast(node)

        self.is_fstring = True
        self.is_format_str_literal = True

        # 构建格式字符串和参数
        format_parts = []
        arg_index = 0

        # 处理 JoinedStr 的 values 属性
        values = getattr(node, "values", [])

        for part in values:
            if isinstance(part, ast.Constant):
                # 字符串常量部分，需要转义大括号
                # Python AST 已经将 {{ 转换为 {，我们需要重新转义为 {{
                constant_value = part.value
                if isinstance(constant_value, str):
                    # 转义单个大括号为双大括号
                    escaped_value = constant_value.replace("{", "{{").replace("}", "}}")
                    format_parts.append(escaped_value)
                else:
                    # 非字符串常量，直接添加
                    format_parts.append(str(constant_value))
            elif hasattr(ast, "FormattedValue") and isinstance(
                part, ast.FormattedValue
            ):
                # 格式化值部分，需要处理格式规范符
                format_spec = ""
                if part.format_spec:
                    # 如果有格式规范符，需要提取
                    if isinstance(part.format_spec, ast.Constant):
                        format_spec = f":{part.format_spec.value}"
                    elif isinstance(part.format_spec, ast.JoinedStr):
                        # JoinedStr 类型的格式规范符，提取其中的常量值
                        spec_parts = []
                        for spec_part in part.format_spec.values:
                            if isinstance(spec_part, ast.Constant):
                                spec_parts.append(str(spec_part.value))
                        if spec_parts:
                            format_spec = ":" + "".join(spec_parts)
                    else:
                        # 其他类型的格式规范符，暂时简化处理
                        format_spec = ":" + str(getattr(part.format_spec, "value", ""))

                format_parts.append(f"{{{format_spec}}}")
                # 构建参数表达式
                arg_expr = build_expr_from_ast(part.value, self)
                self.named_args.append((str(arg_index), arg_expr))
                arg_index += 1

        # 组合格式字符串
        self.format_str = "".join(format_parts)
